@fabrika/builder 0.2.0

package/BUILD-CONTRACT.md

@@ -0,0 +1,41 @@
+# Builder contract
+
+## Package boundary
+
+`@fabrika/builder` owns one complete guided-build feature:
+
+- deterministic phase and issue logic under `cli/`
+- the local daemon under `daemon/`
+- the packaged dashboard under `ui/dist/`
+- installed agent support under `skill/`
+- the public stack and technology catalog under `stacks/` and `decisions/`
+
+`@fabrika/cli` is the only public `fabrika` executable. It routes arguments after `fabrika builder` to `runBuilderCli()`.
+
+The builder CLI and dashboard must not import daemon implementation modules. They communicate through HTTP and WebSocket endpoints. The daemon is the only builder layer that imports `@fabrika/canvas-kernel/server`.
+
+## Phase model
+
+The ordered phases are intake, vision, flows, technology, design, skeletons, issues, and build. A phase is complete when every required output exists and its review gate, when present, has submitted and consumed feedback.
+
+The phase is always derived from application files and gate state. No mutable phase counter is authoritative.
+
+## Application state
+
+`fabrika builder init` creates `.fabrika/config.json`, layered artifact directories, and `tests/browser/`. It installs agent support without overwriting user-edited generated files.
+
+The stable session ID identifies dashboard revisions. Persistent daemon state defaults to `~/.fabrika` and can be moved with `FABRIKA_DATA_DIR`.
+
+## Gate protocol
+
+1. `gate open` sends one view or a directory of views to `POST /api/session/:id/plan`.
+2. The daemon compiles the selected canvas files and creates a revision.
+3. The dashboard submits feedback over `/ws/session/:id`.
+4. `gate wait` observes feedback without consuming it.
+5. `advance` validates outputs and consumes the latest feedback.
+
+Only `advance` consumes feedback. This keeps retries and re-opened gates pending until the agent explicitly advances.
+
+## Release artifact
+
+The release packer runs `release:prepare`, which builds the dashboard into `ui/dist/`. The npm package includes runtime source, dashboard assets, skills, decisions, and stack presets. Tests and development-only source are excluded.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Contember Limited
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,100 @@
+# @fabrika/builder
+
+`@fabrika/builder` guides a coding agent from an initial application brief to a reviewed acceptance contract and an assisted implementation.
+
+The builder runs eight deterministic phases:
+
+1. intake
+2. vision
+3. flows
+4. technology
+5. design
+6. opice test skeletons
+7. implementation issues
+8. build
+
+The current phase is derived from files in `.fabrika/`; it is not stored as a mutable counter. Review gates use a local dashboard with persistent annotations and responses.
+
+## Usage
+
+Install the public CLI and initialize the builder in an application repository:
+
+```bash
+bun add --global @fabrika/cli
+fabrika builder init
+```
+
+Initialization installs the Fabrika skill for Claude Code and Codex, starts the local daemon, and opens the dashboard. The coding agent then drives the phase loop.
+
+```text
+fabrika builder next
+do the emitted work
+fabrika builder gate open <phase> --view <canvas.jsx>
+fabrika builder gate wait
+fabrika builder advance
+```
+
+All commands:
+
+```text
+fabrika builder init [dir] [--profile <stack>] [--agent all|claude|codex]
+fabrika builder next [--json]
+fabrika builder advance [--force]
+fabrika builder gate open <name> --view <file.jsx>
+fabrika builder gate wait [--gate <revision>] [--timeout <ms>]
+fabrika builder ensure-daemon
+fabrika builder induce [--force]
+fabrika builder build [--issue <ID>] [--assisted]
+```
+
+Use `--profile cf-internal-app` for the full Buzola, Propustka, and Vozka internal-app stack. The default is `cf-lightweight`.
+
+## Generated application state
+
+```text
+.fabrika/
+  config.json
+  agent-support.json
+  intent/
+  principles/
+  architecture/
+  issues/
+.claude/
+.agents/skills/fabrika/
+.codex/agents/
+tests/browser/*.test.ts
+```
+
+The opice skeletons under `tests/browser/` are the executable acceptance contract. The generated issues form the implementation dependency graph.
+
+## Environment
+
+| Variable             | Purpose                           | Default                             |
+| -------------------- | --------------------------------- | ----------------------------------- |
+| `FABRIKA_PORT`       | Local daemon port                 | `19410`                             |
+| `FABRIKA_SESSION_ID` | Session override                  | Stable hash of the application path |
+| `FABRIKA_DATA_DIR`   | Persistent local state            | `~/.fabrika`                        |
+| `FABRIKA_TIMEOUT`    | Gate wait timeout in milliseconds | `3600000`                           |
+| `FABRIKA_UI_DIST`    | Dashboard build override          | Packaged `ui/dist`                  |
+
+## Package contents
+
+- `cli/` owns phase derivation, task packets, issue induction, and builder commands.
+- `daemon/` owns HTTP/WebSocket endpoints and persistent canvas sessions.
+- `ui/` owns the local dashboard.
+- `skill/` contains the agent-neutral workflow and specialist roles.
+- `decisions/` and `stacks/` contain the public technology catalog.
+
+The public `@fabrika/cli` package exposes this package under `fabrika builder …`. CLI and dashboard clients communicate with the daemon only over HTTP and WebSocket.
+
+## Development
+
+From the `fabrika-platform` repository root:
+
+```bash
+bun run --filter @fabrika/builder typecheck
+bun run --filter @fabrika/builder test
+bun run --filter @fabrika/builder build
+```
+
+See [`BUILD-CONTRACT.md`](./BUILD-CONTRACT.md) for the package boundary and wire contract.

package/cli/src/bin.ts

@@ -0,0 +1,66 @@
+#!/usr/bin/env bun
+
+import { cmdAdvance } from './commands/advance'
+import { cmdBuild } from './commands/build'
+import { cmdEnsureDaemon } from './commands/ensure-daemon'
+import { cmdGate } from './commands/gate'
+import { cmdInduce } from './commands/induce'
+import { cmdInit } from './commands/init'
+import { cmdNext } from './commands/next'
+
+export const BUILDER_USAGE = `fabrika builder — guided application builder
+
+Usage:
+  fabrika builder init [dir] [--profile <stack>] [--agent all|claude|codex]
+                                               Scaffold .fabrika/, install agent support, open dashboard
+  fabrika builder next [--json]                      Print the task packet for the current derived phase
+  fabrika builder advance [--force]                  Validate outputs and gate, then print the next phase
+  fabrika builder gate open <name> --view <f.jsx>    Push a canvas gate and open the dashboard
+  fabrika builder gate wait [--gate <n>] [--timeout] Wait for submitted gate feedback
+  fabrika builder ensure-daemon                      Start the daemon if it is not running
+  fabrika builder induce [--force]                   Derive issues from opice skeleton metadata
+  fabrika builder build [--issue <ID>] [--assisted]  Run the assisted per-issue build driver
+
+Environment:
+  FABRIKA_PORT         Daemon port (default 19410)
+  FABRIKA_SESSION_ID   Session id (fallback: stable hash of repo abs path)
+  FABRIKA_DATA_DIR     Persistent daemon/session data (default ~/.fabrika; legacy auto-detected)
+  FABRIKA_TIMEOUT      gate wait timeout in ms (default 3600000)`
+
+export async function runBuilderCli(argv: readonly string[]): Promise<number> {
+	const command = argv[0]
+	const rest = argv.slice(1)
+
+	if (!command || command === '--help' || command === '-h' || command === 'help') {
+		console.info(BUILDER_USAGE)
+		return command ? 0 : 1
+	}
+
+	switch (command) {
+		case 'init':
+			return cmdInit(rest)
+		case 'next':
+			return cmdNext(rest)
+		case 'advance':
+			return cmdAdvance(rest)
+		case 'gate':
+			return cmdGate(rest)
+		case 'ensure-daemon':
+			return cmdEnsureDaemon(rest)
+		case 'induce':
+			return cmdInduce(rest)
+		case 'build':
+			return cmdBuild(rest)
+		default:
+			console.error(`Unknown builder command: ${command}`)
+			console.info(BUILDER_USAGE)
+			return 1
+	}
+}
+
+if (import.meta.main) {
+	runBuilderCli(process.argv.slice(2)).then((code) => process.exit(code)).catch((error: unknown) => {
+		console.error(error instanceof Error ? error.stack ?? error.message : String(error))
+		process.exit(1)
+	})
+}

package/cli/src/build-status.ts

@@ -0,0 +1,109 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs'
+import { dirname, join } from 'path'
+import type { Issue } from './issues'
+
+export type IssueStatus = 'done' | 'blocked'
+
+export interface BuildRecord {
+	status: IssueStatus
+	reason?: string
+	at: string
+}
+
+export type BuildBoard = Record<string, BuildRecord>
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function parseBoard(value: unknown): BuildBoard | null {
+	if (!isRecord(value)) return null
+	const board: BuildBoard = {}
+	for (const [id, candidate] of Object.entries(value)) {
+		if (!isRecord(candidate)) return null
+		const status = candidate['status']
+		const at = candidate['at']
+		const reason = candidate['reason']
+		if ((status !== 'done' && status !== 'blocked') || typeof at !== 'string') return null
+		if (reason !== undefined && typeof reason !== 'string') return null
+		board[id] = { status, at, ...(reason === undefined ? {} : { reason }) }
+	}
+	return board
+}
+
+function boardPath(fabrikaDir: string): string {
+	return join(fabrikaDir, 'build', 'status.json')
+}
+
+export function readBoard(fabrikaDir: string): BuildBoard {
+	const p = boardPath(fabrikaDir)
+	if (!existsSync(p)) return {}
+	try {
+		const board = parseBoard(JSON.parse(readFileSync(p, 'utf-8')))
+		return board ?? {}
+	} catch {
+		return {}
+	}
+}
+
+export function writeBoard(fabrikaDir: string, board: BuildBoard): void {
+	const p = boardPath(fabrikaDir)
+	mkdirSync(dirname(p), { recursive: true })
+	writeFileSync(p, JSON.stringify(board, null, 2) + '\n')
+}
+
+export function record(
+	fabrikaDir: string,
+	id: string,
+	status: IssueStatus,
+	reason: string | undefined,
+	at: string,
+): BuildBoard {
+	const board = readBoard(fabrikaDir)
+	board[id] = { status, ...(reason ? { reason } : {}), at }
+	writeBoard(fabrikaDir, board)
+	return board
+}
+
+export interface BuildPlan {
+	done: Issue[]
+	blocked: Issue[]
+	ready: Issue[]
+	waiting: Issue[]
+	next: Issue | null
+	complete: boolean
+}
+
+export function planBuild(issues: Issue[], board: BuildBoard): BuildPlan {
+	const statusOf = (id: string): IssueStatus | undefined => board[id]?.status
+	const doneIds = new Set(issues.filter((i) => statusOf(i.id) === 'done').map((i) => i.id))
+
+	const done: Issue[] = []
+	const blocked: Issue[] = []
+	const ready: Issue[] = []
+	const waiting: Issue[] = []
+
+	for (const issue of issues) {
+		const s = statusOf(issue.id)
+		if (s === 'done') {
+			done.push(issue)
+			continue
+		}
+		if (s === 'blocked') {
+			blocked.push(issue)
+			continue
+		}
+		const depsDone = issue.dependsOn.every((d) => doneIds.has(d))
+		if (depsDone) ready.push(issue)
+		else waiting.push(issue)
+	}
+
+	return {
+		done,
+		blocked,
+		ready,
+		waiting,
+		next: ready[0] ?? null,
+		complete: ready.length === 0 && waiting.length === 0 && done.length + blocked.length === issues.length && issues.length > 0,
+	}
+}

package/cli/src/catalog.ts

@@ -0,0 +1,42 @@
+import { existsSync, statSync } from 'fs'
+import { dirname, join, resolve } from 'path'
+import { fileURLToPath } from 'url'
+
+const HERE = dirname(fileURLToPath(import.meta.url))
+
+export function resolveCatalogRoot(): string | null {
+	const candidates = [resolve(HERE, '../..')]
+	for (const c of candidates) {
+		if (isDir(join(c, 'stacks')) && isDir(join(c, 'decisions'))) return c
+	}
+	return null
+}
+
+export interface StackPointer {
+	profile: string
+	root: string
+	stackFile: string
+	stackFileExists: boolean
+	decisionsDir: string
+}
+
+export function resolveStackPointer(profile: string): StackPointer | null {
+	const root = resolveCatalogRoot()
+	if (!root) return null
+	const stackFile = join(root, 'stacks', `${profile}.md`)
+	return {
+		profile,
+		root,
+		stackFile,
+		stackFileExists: existsSync(stackFile) && statSync(stackFile).isFile(),
+		decisionsDir: join(root, 'decisions'),
+	}
+}
+
+function isDir(p: string): boolean {
+	try {
+		return statSync(p).isDirectory()
+	} catch {
+		return false
+	}
+}

package/cli/src/commands/advance.ts

@@ -0,0 +1,73 @@
+import { parseArgs } from 'util'
+import { resolveContext } from '../context'
+import { consumeFeedback, isDaemonRunning } from '../daemon-client'
+import { isNonEmptyFile, matchGlob, producesSatisfied } from '../derive'
+import { resolvePhaseState } from '../phase-state'
+import { PHASE_COUNT, phaseById, phaseIndex, PHASES } from '../phases'
+
+export async function cmdAdvance(argv: string[]): Promise<number> {
+	const { values } = parseArgs({
+		args: argv,
+		options: {
+			force: { type: 'boolean', default: false },
+			dir: { type: 'string' },
+			session: { type: 'string' },
+		},
+		allowPositionals: true,
+	})
+
+	const ctx = resolveContext({ dir: values.dir, session: values.session })
+	if (!ctx.initialized) {
+		console.error(`[fabrika] no .fabrika/ found at or above ${ctx.repoRoot}. Run \`fabrika builder init\` first.`)
+		return 1
+	}
+
+	const { state } = await resolvePhaseState(ctx.repoRoot, ctx.fabrikaDir, ctx.sessionId)
+	const phase = phaseById(state.current)
+	const problems: string[] = []
+
+	if (!producesSatisfied(ctx.repoRoot, phase)) {
+		for (const glob of phase.produces) {
+			if (glob.startsWith('<')) {
+				problems.push(`missing produce: ${glob} (manual/terminal — cannot auto-validate)`)
+				continue
+			}
+			const matches = matchGlob(ctx.repoRoot, glob).filter(isNonEmptyFile)
+			if (matches.length === 0) problems.push(`missing produce: ${glob}`)
+		}
+	}
+
+	if (phase.gate && !values.force) {
+		const daemonUp = await isDaemonRunning()
+		if (!daemonUp) {
+			problems.push(
+				`gate "${phase.id}" cannot be validated offline (daemon down). `
+					+ `Open the gate + submit feedback, or pass --force.`,
+			)
+		} else {
+			const feedback = await consumeFeedback(ctx.sessionId)
+			if (feedback === null) {
+				problems.push(
+					`gate "${phase.id}" has no submitted feedback to consume. `
+						+ `Run: fabrika builder gate open ${phase.id} --view ${phase.gateView ?? phase.id + '.jsx'} && fabrika builder gate wait`,
+				)
+			}
+		}
+	}
+
+	if (problems.length > 0) {
+		console.error(`[fabrika] cannot advance from phase ${phase.number}/${PHASE_COUNT} (${phase.id}):`)
+		for (const p of problems) console.error(`  - ${p}`)
+		return 1
+	}
+
+	const idx = phaseIndex(phase.id)
+	const next = idx + 1 < PHASES.length ? PHASES[idx + 1] : null
+	if (next) {
+		console.log(`OK: phase ${phase.number}/${PHASE_COUNT} (${phase.id}) satisfied.`)
+		console.log(`Next -> phase ${next.number}/${PHASE_COUNT} - ${next.title}. Run \`fabrika builder next\`.`)
+	} else {
+		console.log(`OK: all ${PHASE_COUNT} phases satisfied. Run \`fabrika builder build\`.`)
+	}
+	return 0
+}

package/cli/src/commands/build.ts

@@ -0,0 +1,215 @@
+import { join } from 'path'
+import { parseArgs } from 'util'
+import { type BuildPlan, planBuild, readBoard, record } from '../build-status'
+import { resolveStackPointer } from '../catalog'
+import { resolveContext } from '../context'
+import { postBuildEvent } from '../daemon-client'
+import { type Issue, readIssues } from '../issues'
+
+export async function cmdBuild(argv: string[]): Promise<number> {
+	const { values, positionals } = parseArgs({
+		args: argv,
+		options: {
+			reason: { type: 'string' },
+			issue: { type: 'string' },
+			dir: { type: 'string' },
+			session: { type: 'string' },
+			assisted: { type: 'boolean', default: false },
+		},
+		allowPositionals: true,
+	})
+
+	const sub = positionals[0] ?? 'next'
+	const idArg = positionals[1] ?? values.issue
+
+	const ctx = resolveContext({ dir: values.dir, session: values.session })
+	if (!ctx.initialized) {
+		console.error(`[fabrika] no .fabrika/ found at or above ${ctx.repoRoot}. Run \`fabrika builder init\` first.`)
+		return 1
+	}
+
+	const issues = readIssues(ctx.fabrikaDir)
+	if (issues.length === 0) {
+		console.error(
+			`[fabrika] no issues in ${ctx.fabrikaDir}/issues/. Run \`fabrika builder induce\` (phase 7) first.`,
+		)
+		return 1
+	}
+	const byId = (id: string) => issues.find((i) => i.id === id) ?? null
+
+	switch (sub) {
+		case 'status':
+			printBoard(planBuild(issues, readBoard(ctx.fabrikaDir)))
+			return 0
+
+		case 'done': {
+			if (!idArg || !byId(idArg)) {
+				console.error(`[fabrika] build done <ISSUE-ID> — unknown or missing issue id.`)
+				return 1
+			}
+			record(ctx.fabrikaDir, idArg, 'done', undefined, new Date().toISOString())
+			await postBuildEvent({ issue: idArg, status: 'passed', message: 'issue green (bun test passed)' })
+			console.log(`[fabrika] ✓ ${idArg} marked done.`)
+			return await reportProgress(issues, ctx.fabrikaDir)
+		}
+
+		case 'block': {
+			if (!idArg || !byId(idArg)) {
+				console.error(`[fabrika] build block <ISSUE-ID> --reason "…" — unknown or missing issue id.`)
+				return 1
+			}
+			const reason = values.reason ?? 'blocked (no reason given)'
+			record(ctx.fabrikaDir, idArg, 'blocked', reason, new Date().toISOString())
+			await postBuildEvent({ issue: idArg, status: 'blocked', message: reason })
+			console.log(`[fabrika] ⚠ ${idArg} blocked: ${reason}`)
+			console.log(`[fabrika] continuing to independent issues; collect blocked at final review.`)
+			return await reportProgress(issues, ctx.fabrikaDir)
+		}
+
+		case 'next':
+		default: {
+			if (values.issue && byId(values.issue)) {
+				await postBuildEvent({ issue: values.issue, status: 'running', message: 'building (re-selected)' })
+				process.stdout.write('\n' + renderBuildPacket(byId(values.issue)!, ctx.repoRoot, ctx.profile))
+				return 0
+			}
+			return await emitBrief(issues, ctx.fabrikaDir, ctx.repoRoot, ctx.profile)
+		}
+	}
+}
+
+async function emitBrief(
+	issues: Issue[],
+	fabrikaDir: string,
+	repoRoot: string,
+	profile: string,
+): Promise<number> {
+	const plan = planBuild(issues, readBoard(fabrikaDir))
+	printSummary(plan)
+
+	if (plan.complete) {
+		return await reportComplete(plan, issues.length)
+	}
+
+	await postBuildEvent({
+		status: 'info',
+		message: `build: ${plan.done.length}/${issues.length} done, ${plan.ready.length} ready`,
+	})
+	process.stdout.write('\n' + renderOrchestrationBrief(plan, repoRoot, profile))
+	return 0
+}
+
+async function reportProgress(issues: Issue[], fabrikaDir: string): Promise<number> {
+	const plan = planBuild(issues, readBoard(fabrikaDir))
+	if (plan.complete) return await reportComplete(plan, issues.length)
+	printBoard(plan)
+	if (!plan.next && plan.waiting.length) {
+		console.error(`\n[fabrika] nothing buildable: ${plan.waiting.length} waiting on blocked deps (see final review).`)
+	}
+	return 0
+}
+
+async function reportComplete(plan: BuildPlan, total: number): Promise<number> {
+	await postBuildEvent({ status: 'info', message: `build complete: ${plan.done.length}/${total} green` })
+	console.log(
+		`\n[fabrika] ✓ build complete — ${plan.done.length}/${total} issues green`
+			+ (plan.blocked.length ? `, ${plan.blocked.length} blocked (see final review).` : '.'),
+	)
+	if (plan.blocked.length) {
+		console.log(`\nBlocked (final review):`)
+		for (const b of plan.blocked) console.log(`  ⚠ ${b.id}  ${b.goal}`)
+	}
+	return 0
+}
+
+function printSummary(plan: BuildPlan): void {
+	const total = plan.done.length + plan.blocked.length + plan.ready.length + plan.waiting.length
+	console.log(
+		`build: ${plan.done.length}/${total} done · ${plan.ready.length} ready · `
+			+ `${plan.waiting.length} waiting · ${plan.blocked.length} blocked`,
+	)
+}
+
+function printBoard(plan: BuildPlan): void {
+	printSummary(plan)
+	const line = (label: string, xs: Issue[]) => xs.length && console.log(`\n${label}:\n` + xs.map((i) => `  ${i.id}  ${i.goal}`).join('\n'))
+	line('✓ done', plan.done)
+	line('→ ready', plan.ready)
+	line('… waiting', plan.waiting)
+	line('⚠ blocked', plan.blocked)
+}
+
+function stackBriefLines(profile: string): string[] {
+	const p = resolveStackPointer(profile)
+	if (!p) return []
+	if (!p.stackFileExists) {
+		return [
+			`Stack:       ${profile} — preset NOT found; pick one of ${join(p.root, 'stacks')}/*.md (decisions under ${p.decisionsDir}/)`,
+		]
+	}
+	return [
+		`Stack:       ${profile} -> ${p.stackFile}`,
+		`             resolve its \`decisions:\` ids under ${p.decisionsDir}/ and read the live \`sources\` they pin`,
+	]
+}
+
+function renderOrchestrationBrief(plan: BuildPlan, repoRoot: string, profile: string): string {
+	const marker = new Map<string, string>()
+	for (const i of plan.done) marker.set(i.id, '✓')
+	for (const i of plan.blocked) marker.set(i.id, '⚠')
+	for (const i of plan.ready) marker.set(i.id, '→')
+	for (const i of plan.waiting) marker.set(i.id, '…')
+	const all = [...plan.done, ...plan.ready, ...plan.waiting, ...plan.blocked].sort((a, b) => a.id.localeCompare(b.id))
+	const doneIds = new Set(plan.done.map((i) => i.id))
+
+	const dag = all.map((i) => {
+		const deps = i.dependsOn.length ? `  deps: ${i.dependsOn.join(', ')}` : ''
+		const note = marker.get(i.id) === '…'
+			? `  (waiting on ${i.dependsOn.filter((d) => !doneIds.has(d)).join(', ')})`
+			: ''
+		return `  ${marker.get(i.id) ?? '?'} ${i.id}  ${i.goal}${deps}${note}`
+	})
+
+	return [
+		`## Build — ${all.length} issues`,
+		`Apply the bundled **agents/build-orchestrator.md** playbook in the MAIN session.`,
+		`Do not spawn a nested orchestrator. SUPERVISE and fan out one direct`,
+		`implementer subagent per issue (use the fabrika-implementer role; worktree-isolated`,
+		`where they run in parallel). Do NOT hand-code the whole DAG yourself.`,
+		``,
+		`Repo:  ${repoRoot}`,
+		``,
+		`Issue DAG (foundation first; build independents in parallel):`,
+		...dag,
+		``,
+		`Per issue:   implement → opice-author (selectors vs the running app) → \`bun test\` green.`,
+		`Acceptance:  the issue's \`satisfies\` scenarios + FROZEN invariants must pass.`,
+		`             Never weaken an invariant statement to go green — adversarially verify it.`,
+		...stackBriefLines(profile),
+		`Scaffold:    NO templates — read the stack preset + its decisions + the live sources`,
+		`             they point to, and scaffold from current APIs (your memory is likely stale).`,
+		`Record:      fabrika builder build done <ID>   |   fabrika builder build block <ID> --reason "…"`,
+		`             (both write status.json + stream a BuildEvent to the dashboard)`,
+		`Detail:      fabrika builder build --issue <ID>   (re-emit one issue's full packet)`,
+	].join('\n') + '\n'
+}
+
+function renderBuildPacket(issue: Issue, repoRoot: string, profile: string): string {
+	const lines: string[] = []
+	lines.push(`## Build issue ${issue.id}`)
+	lines.push(`Goal:      ${issue.goal || '(no goal recorded)'}`)
+	lines.push(`Satisfies: ${issue.satisfies.length ? issue.satisfies.join(', ') : '(none)'}`)
+	lines.push(`Depends:   ${issue.dependsOn.length ? issue.dependsOn.join(', ') : '(none)'}`)
+	lines.push(`Touches:   ${issue.touches.length ? issue.touches.join(', ') : '(none)'}`)
+	const sp = resolveStackPointer(profile)
+	if (sp?.stackFileExists) {
+		lines.push(`Stack:     ${profile} -> ${sp.stackFile}  (decisions under ${sp.decisionsDir}/)`)
+	}
+	lines.push(`Pipeline:  implement -> opice-author (selectors vs running app) -> bun test (steps + invariants)`)
+	lines.push(`Done when: green \`bun test\` for the satisfied scenarios/invariants.`)
+	lines.push(`Repo:      ${repoRoot}`)
+	lines.push(``)
+	lines.push(`After green:  fabrika builder build done ${issue.id}    (records it + emits the next packet)`)
+	lines.push(`If stuck:     fabrika builder build block ${issue.id} --reason "…"   (escalate, continue)`)
+	return lines.join('\n') + '\n'
+}